\documentclass{beamer}

%----------------------Package et options-----------------------------
\usepackage[titles]{mypack}
\usepackage{tikz}
\usetheme{Berkeley}
\usecolortheme{seahorse}
%\usetheme{Hannover}
\usefonttheme[onlylarge]{structurebold}
\setbeamerfont*{frametitle}{size=\normalsize,series=\bfseries}
\setbeamertemplate{navigation symbols}{}
\setbeamertemplate{blocks}[rounded][shadow=true]

% Commande pour les noms de section
\newcommand{\secName}{Nom de section}

%-------------------------Page de garde-------------------------------

\title[] 
{%
  Technologies Logicielles Avancées \\
  Le Langage \fan
}

\author[]
{%
  Thibault BAILLARD \and \\%
  Olivier BLONDEAU \and \\%
  Christian GLACET \and \\%
  Julie VALENCIA
}

\date[WABI 2009]
{Université de Bordeaux 1, 2009-2010}

\begin{document}

\logo{\structure{\insertframenumber\,/\,\inserttotalframenumber}}

\begin{frame}
  \titlepage
\end{frame}
%%%%-------------total      : 15 minutes

%---------------------------Sommaire---------------------------------

%----------------intro      : 3.30 minutes 
%----------------syntaxe    : 3.30 minutes  
%----------------lacunes    : 3.30 minutes  
%----------------conclusion : 3.30 minutes  
\begin{frame}{Sommaire}
  \tableofcontents
\end{frame}

%----------------------------Intro-----------------------------------
\renewcommand{\secName}{Introduction}
\section{Introduction}

%%% POSITIONNEMENT ----------------------------

\subsection{Historique}

% HISTORIQUE ----------------------
\begin{frame}{\secName~: Historique}
     	\begin{itemize}
    		\item $Fan$ est créé en 2005
    		\item Première version en Avril 2008
    		\item Première version de l'$IDE$ en Juillet 2009
    		\item Renommage en Novembre 2009 : $Fan$ devient $Fantom$
    	\end{itemize}
\image{0.2}{hist}{}
\end{frame}

\subsection{Portabilité}

% PORTABILITE ----------------------
\begin{frame}{\secName~: Portabilité}
    \begin{block}{La Compilation : le $fcode$}
     	\begin{itemize}
    		\item La machine virtuelle $Java$
    		\item Le $Common$ $Language$ $Runtime$ de $.NET$
    	\end{itemize}   	
    \end{block}
    \begin{block}{La Modularité : les $pods$}
     	\begin{itemize}
    		\item Ni des $packages$, ni des $.jar$
    		\item Ni des $.dll$
		\item Une simple archive
    	\end{itemize}  
    \end{block}
\begin{tabular}{rrrrrr}
\includegraphics[scale = 0.1]{Images/java.png} & \Huge{+} & \includegraphics[scale = 0.2]{Images/net.jpg} & \Huge{=} & \includegraphics[scale = 0.2]{Images/loading.png}{} & \Huge{?} \\
\end{tabular}
\end{frame}

\subsection{Multi-paradigme}


% MULTIPARADIGME ----------------------
\begin{frame}{\secName~: Multi-paradigme (1/2)}
	Le $pattern$ Stratégie : Programmation Orientée Objet \jump
	\includegraphics[scale = 0.5]{Images/strat1.png}
\end{frame}


\begin{frame}{\secName~: Multi-paradigme (2/2)}
	Passer des fonctions en paramètre : Programmation Fonctionelle \jump
	\includegraphics[scale = 0.5]{Images/strat2.png}
\end{frame}

% 
\section{Facilités}

%----------------------------Syntaxe-----------------------------------

\renewcommand{\secName}{Facilités~}
\subsection{Appels sécurisés}

\begin{frame}[containsverbatim]{\secName : Les appels sécurisés (ou "safes-invokes")}

En java : 
\begin{code}
String nom = null;
if (liste != null) {
  Utilisateur u = liste.trouve("bob");
  if (u != null)
       nom = u.nom;
}
\end{code}

En \fan~:
\begin{code}
Str? nom := liste?.trouve("bob")?.nom
\end{code}
\end{frame}  


\subsection{Invocation dynamique}
\begin{frame}[containsverbatim]{\secName : Invocations dynamiques (1/2)}
Deux objets ayant une méthode $move$ :
\begin{code}
class Chien{
    [...]
    Int? xPos;
    public Void move (Int newX) { xPos = newX; }
}

class Forme{
    [...]
    Int? xPosition;
    public Void move (Int x) { xPosition = x; }
}
\end{code}
\end{frame}

\begin{frame}[containsverbatim]{\secName : Invocations dynamiques (2/2)}
Appel de $move$ sur un Object :
\begin{code}
waouf := Chien() { xPos=1; }
forme := Forme() { xPosition=20; }

machin := null;  // création d'un Object null
if (true)
    machin = waouf
else
    machin = forme
        
machin->move(5) // --> Duck typing
// machin.move(5)  --> Unknown method 'sys::Obj.move'
\end{code}
\end{frame}


\subsection{La sérialization}
\begin{frame}[containsverbatim]{\secName : La sérialization (1/2)}
L'objet sérializable :
\begin{code}
@serializable class Person2{
    Str? name; Int? age; Str[]? children;
}
    
homer := Person2() {
    name="Homer Simpson";
    age=39;
    children=["Bart", "Lisa", "Maggie"];
}
Sys.out.writeObj(homer);
\end{code}
\end{frame}


\begin{frame}[containsverbatim]{\secName : La sérialization (2/2)}
Résultat :
\begin{code}
First::Person2
{
name="Homer Simpson"
age=39
children=["Bart","Lisa","Maggie"]
\end{code}
\end{frame}


\subsection{Méthodes $get$ et $set$}
\begin{frame}[containsverbatim]{\secName : Création automatique des méthodes $get$ et $set$ (1/2)}
Version Java :
\begin{code}
public class Person
{
  public String name() { return name; }
  public void name(String x) { name = x; }

  public int age() { return age; }
  public void age(int x) { age = x; }

  private String name;
  private int age;
}
\end{code}
\begin{code}
Person p = new Person();
System.out.println(p.name());
\end{code}
\end{frame}


\begin{frame}[containsverbatim]{\secName : Création automatique des méthodes $get$ et $set$ (2/2)}
Version \fan~:
\begin{code}
class Person
{
  Str name
  Int age
}
\end{code}
\begin{code}
p := Person()
echo(p.name())
\end{code}
\end{frame}

\subsection{Closures}
\begin{frame}[containsverbatim]{\secName : Closures (1/2)}
Version Java : 
\begin{code}
for (int i = 0 ; i < 10 ; ++i) {
  System.out.println("i = " + i);
}
\end{code}
\end{frame}

\begin{frame}[containsverbatim]{\secName : Closures (2/2)}
Le même code en \fan~: 
\begin{code}
10.times |i| { echo("i = $i") }
\end{code} %$NE PAS SUPPRIMER CE \$
\jump
ou en utilisant le paramètre implicite \textit{it} (inférence de type) :
\begin{code}
10.times { echo("i = $it") }
\end{code} %$NE PAS SUPPRIMER CE \$
\end{frame}




%----------------------------les Lacunes-----------------------------------

\section{Les Lacunes}

\renewcommand{\secName}{Les Lacunes}
\subsection{L'IDE}

\begin{frame}{\secName~: Environnement de développement intégré}
    \image{0.2}{fantomide}{\fan IDE : un plugin Netbeans}
    \begin{itemize}
		\item Un IDE \alert{en cours de développement}.
    \end{itemize}
\end{frame}
\definecolor{darkgreen}{rgb}{0.3,0.7,0.3}

\subsection{Prise en main}
\begin{frame}[containsverbatim]{\secName~: Prise en main (1/2)}
    	\begin{itemize}
			\item Lisibilité du langage.
    	\end{itemize}
\begin{code}
// Map
map := [5:"cinq", 7:"sept", 2:"deux"]
\end{code}
\begin{code}
// Itération Fantom
map.each |Str v, Int k| { echo("$v[$k]")}
\end{code}
\begin{code}
// Itération Java
for (Entry<Integer, String> c : m.entrySet()) {
  System.out.println(c.getKey()+"["+c.getValue()+"]");
}
\end{code}
\end{frame}
\begin{frame}[containsverbatim]{\secName~: Prise en main (2/2)}
    \begin{block}{L'aide en ligne}
    	\begin{itemize}
			\item La communauté n'est \alert{pas très importante}.
            \item Les créateurs sont \textcolor{blue}{très présents}.
    	\end{itemize}
    \end{block}
    \begin{block}{La documentation}
    	\begin{itemize}
			\item La documentation est \textcolor{blue}{bien écrite}.
            \item Les exemples sont parfois \alert{faux}.
            \item \textcolor{darkgreen}{Evolution constante du langage}.
    	\end{itemize}
    \end{block}

\end{frame}

\subsection{Import de bibliothèque}
\begin{frame}[containsverbatim]{\secName~: Import de bibliothèque (1/2)}
    \begin{exampleblock}{L'import en théorie}
    	\begin{itemize}
			\item \textit{using} MaBiblio.
    	\end{itemize}
    \end{exampleblock}
    \begin{block}{L'import en vérité}
    	\begin{itemize}
        \item L'importation se fait en 2 temps : \alert{Le \textit{using} ne suffit pas}.
    	\end{itemize}
        \begin{code}
// ---- Classe Pod ----
@podDepends = [Depend("sys 1.0"), Depend("MaBiblio") ]
@podSrcDirs = [‘fan/‘, ‘test/‘]
pod HelloWorld { }
        \end{code}

    \end{block}

\end{frame}

\begin{frame}[containsverbatim]{\secName~: Import de bibliothèque (2/2)}
    	\begin{itemize}
        \item Le \textit{using} a un emplacement \alert{précis}.
    	\end{itemize}
        \begin{code}
using gfx
**
** Main
**
class Main
{
    **
    ** Main method
    **
    static Void main(){ 
        Window { Label{ text = "Hello World"; },
        }.open
}}
        \end{code}
\end{frame}

%--------------------------Conclusion---------------------------------
\renewcommand{\secName}{Conclusion\xspace}
\section*{\secName}

\begin{frame}{\secName~: }
    \begin{exampleblock}{Points positifs}
    	\begin{itemize}
    		\item Portabilité
    		\item Multi-Paradigme
    		\item Une API très fournie
    		\item Les objets nullables
    		\item L'invocation dynamique
    	\end{itemize}
    \end{exampleblock}
   \begin{alertblock}{Points négatifs}
    	\begin{itemize}
    		\item \fan est un langage jeune.
    		\item Prise en main - Lisibilité
    		\item Documentation pas à jour
    	\end{itemize}
    \end{alertblock}
\end{frame}
\end{document}

